/**
 * 本地存储工具类
 */

/**
 * 本地存储工具类 & API 基础配置
 */

// API 基础地址（统一管理）
// 优先使用环境变量，其次使用运行时 window 配置，默认走相对路径 /api 以配合 Nginx 反向代理避免跨域
const fromEnv = (typeof import.meta !== 'undefined' && import.meta.env && import.meta.env.VITE_API_BASE_URL) || undefined;
const fromWindow = (typeof window !== 'undefined' && window.__APP_CONFIG__ && window.__APP_CONFIG__.API_BASE_URL) || undefined;
// 统一去掉尾部斜杠，避免拼接出现双斜杠
export const API_BASE_URL = ((fromEnv || fromWindow || '/api').replace(/\/+$/, ''));
// 存储键名
const STORAGE_KEYS = {
  CONTAINERS: 'time_capsule_containers', //常用
  MIND_ARCHIVES: 'time_capsule_mind_archives',//常用
  CAMPFIRE_POSTS: 'time_capsule_campfire_posts',
  CAMPFIRE_REPLIES: 'time_capsule_campfire_replies',
  CAMPFIRE_USER_REPUTATION: 'time_capsule_campfire_user_reputation',
  PLANS: 'time_capsule_plans' // 计划数据
}

/**
 * 保存数据到本地存储
 * @param {string} key 存储键名
 * @param {any} data 要存储的数据
 */
export function saveToStorage(key, data) {
  try {
    const jsonData = JSON.stringify(data)
    // TODO: 替换为 API 调用
    localStorage.setItem(key, jsonData)
    return true
  } catch (error) {
    console.error('保存数据到本地存储失败:', error)
    return false
  }
}

/**
 * 从数据库查询数据（暂时使用本地存储）
 * @param {string} key 存储键名
 * @returns {Promise<any>} 查询结果
 */
export async function getFromAPI(key) {
  try {
    // 暂时使用本地存储，后续替换为 API 调用
    // TODO: 替换为实际的 API 调用
    // API 接口设计：GET ${API_BASE_URL}/data/${key}
    // 返回格式：{ success: true, data: any, message?: string }
    // 错误格式：{ success: false, error: string, code?: number }
    
    const localData = localStorage.getItem(key);
    if (localData === null) {
      return null; // 没有数据时返回 null
    }
    return JSON.parse(localData);
    
    /* 正式 API 调用代码（暂时注释）：
    const response = await fetch(`${API_BASE_URL}/data/${key}`, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
    });
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const result = await response.json();
    if (!result.success) {
      throw new Error(result.error || '获取数据失败');
    }
    
    return result.data;
    */
  } catch (error) {
    console.error('从数据库查询数据失败:', error);
    throw error;
  }
}

/**
 * 保存数据到 API（暂时使用本地存储）
 * @param {string} key 存储键名
 * @param {any} data 要存储的数据
 * @returns {Promise<boolean>} 是否保存成功
 */
export async function saveToAPI(key, data) {
  try {
    // 暂时使用本地存储，后续替换为 API 调用
    // TODO: 替换为实际的 API 调用
    // API 接口设计：POST ${API_BASE_URL}/data/${key}
    // 请求体：{ data: any }
    // 返回格式：{ success: true, message?: string }
    // 错误格式：{ success: false, error: string, code?: number }
    
    const jsonData = JSON.stringify(data);
    localStorage.setItem(key, jsonData);
    return true;
    
    /* 正式 API 调用代码（暂时注释）：
    const response = await fetch(`${API_BASE_URL}/data/${key}`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
      body: JSON.stringify({ data }),
    });

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }

    const result = await response.json();
    if (!result.success) {
      throw new Error(result.error || '保存数据失败');
    }

    return true;
    */
  } catch (error) {
    console.error('保存数据到 API 失败:', error);
    return false;
  }
}



/**
 * 从本地存储获取数据
 * @param {string} key 存储键名
 * @param {any} defaultValue 默认值（如果没有找到数据）
 * @returns {any} 存储的数据或默认值
 */
export function getFromStorage(key, defaultValue = null) {
  try {
    // TODO: 替换为 API 调用
    const jsonData = localStorage.getItem(key)
    if (jsonData === null) return defaultValue
    return JSON.parse(jsonData)
  } catch (error) {
    console.error('从本地存储获取数据失败:', error)
    return defaultValue
  }
}

/**
 * 从本地存储删除数据
 * @param {string} key 存储键名
 */
export function removeFromStorage(key) {
  try {
    // TODO: 替换为 API 调用
    localStorage.removeItem(key)
    return true
  } catch (error) {
    console.error('从本地存储删除数据失败:', error)
    return false
  }
}

/**
 * 清空本地存储
 */
export function clearStorage() {
  try {
    // TODO: 替换为 API 调用
    localStorage.clear()
    return true
  } catch (error) {
    console.error('清空本地存储失败:', error)
    return false
  }
}

export { STORAGE_KEYS }

// ==================== 计划相关API接口 ====================

/**
 * 获取计划列表（专用接口）
 * @returns {Promise<Array>} 计划列表
 */
export async function getPlansAPI() {
  try {
    // 使用正式的 API 调用，匹配后端 Controller
    // API 接口设计：GET ${API_BASE_URL}/plans
    // 返回格式：{ code: 200, message: string, data: Array }
    // 错误格式：{ code: number, message: string }
    
    const response = await fetch(`${API_BASE_URL}/plans`, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
    });
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(result.message || '获取计划列表失败');
    }
    
    // 确保所有计划ID都是数字类型
    const plans = result.data || [];
    plans.forEach(plan => {
      if (plan.id && typeof plan.id === 'string') {
        plan.id = Number(plan.id);
      }
      if (plan.containerIds) {
        plan.containerIds = plan.containerIds.map(id => 
          typeof id === 'string' ? Number(id) : id
        );
      }
    });
    
    return plans;
    
  } catch (error) {
    console.warn('API调用失败，使用本地存储:', error);
    // 如果 API 调用失败，尝试使用本地存储作为备用
    try {
      const localData = localStorage.getItem(STORAGE_KEYS.PLANS);
      if (localData !== null) {
      console.warn('使用本地存储作为备用');
      const data = JSON.parse(localData);
      // 确保本地数据中ID也是数字类型
      if (Array.isArray(data)) {
        data.forEach(plan => {
          if (plan.id && typeof plan.id === 'string') {
            plan.id = Number(plan.id);
          }
          if (plan.containerIds) {
            plan.containerIds = plan.containerIds.map(id => 
              typeof id === 'string' ? Number(id) : id
            );
          }
        });
      }
      return data;
      }
    } catch (localError) {
      console.error('本地存储备用也失败:', localError);
    }
    throw error;
  }
}

/**
 * 保存计划列表（专用接口）
 * @param {Array} plans 计划列表
 * @returns {Promise<boolean>} 是否保存成功
 */
export async function savePlansAPI(plans) {
  try {
    // 暂时使用本地存储，后续替换为 API 调用
    // TODO: 替换为实际的 API 调用
    // API 接口设计：POST ${API_BASE_URL}/plans/time_capsule_plans
    // 请求体：{ data: Array }
    // 返回格式：{ success: true, message?: string }
    // 错误格式：{ success: false, error: string, code?: number }
    
    const jsonData = JSON.stringify(plans);
    localStorage.setItem(STORAGE_KEYS.PLANS, jsonData);
    return true;
    
    /* 正式 API 调用代码（暂时注释）：
    const response = await fetch(`${API_BASE_URL}/plans/time_capsule_plans`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
      body: JSON.stringify({ data: plans }),
    });

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }

    const result = await response.json();
    if (!result.success) {
      throw new Error(result.error || '保存计划列表失败');
    }

    return true;
    */
  } catch (error) {
    console.error('保存计划列表失败:', error);
    return false;
  }
}

/**
 * 创建新计划
 * @param {Object} planData 计划数据
 * @returns {Promise<string>} 返回创建的计划ID
 */
export async function createPlanAPI(planData) {
  try {
    // 使用正式的 API 调用，匹配后端 Controller
    // API 接口设计：POST ${API_BASE_URL}/plans
    // 请求体：{ title, description, category, date, startTime, endTime, priority, color }
    // 返回格式：{ code: 200, message: string, data: { id: string } }
    // 错误格式：{ code: number, message: string }
    
    const response = await fetch(`${API_BASE_URL}/plans`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
      body: JSON.stringify(planData),
    });
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(result.message || '创建计划失败');
    }
    
    // 确保返回的ID是数字类型
    const planId = result.data.id;
    return typeof planId === 'string' ? Number(planId) : planId;
    
  } catch (error) {
    console.warn('API调用失败，使用本地存储:', error);
    // 如果 API 调用失败，尝试使用本地存储作为备用
    try {
      const planId = Number(Date.now()); // 确保生成数字类型ID
      const newPlan = {
        id: planId,
        ...planData,
        containerIds: [],
        status: 'pending',
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString()
      };
      
      const existingPlans = await getPlansAPI();
      existingPlans.push(newPlan);
      await savePlansAPI(existingPlans);
      
      console.warn('使用本地存储作为备用创建计划');
      return planId;
    } catch (localError) {
      console.error('本地存储备用也失败:', localError);
    }
    throw error;
  }
}

/**
 * 更新计划
 * @param {string} planId 计划ID
 * @param {Object} updateData 更新的数据
 * @returns {Promise<boolean>} 是否更新成功
 */
export async function updatePlanAPI(planId, updateData) {
  try {
    // 使用正式的 API 调用，匹配后端 Controller
    // API 接口设计：PUT ${API_BASE_URL}/plans/${planId}
    // 请求体：{ ...updateData }
    // 返回格式：{ code: 200, message: string }
    // 错误格式：{ code: number, message: string }
    
    const response = await fetch(`${API_BASE_URL}/plans/${planId}`, {
      method: 'PUT',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
      body: JSON.stringify(updateData),
    });
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(result.message || '更新计划失败');
    }
    
    return true;
    
  } catch (error) {
    console.warn('API调用失败，使用本地存储:', error);
    // 如果 API 调用失败，尝试使用本地存储作为备用
    try {
      const plans = await getPlansAPI();
      const planIndex = plans.findIndex(p => p.id === planId);
      
      if (planIndex === -1) {
        throw new Error('计划不存在');
      }
      
      plans[planIndex] = {
        ...plans[planIndex],
        ...updateData,
        updatedAt: new Date().toISOString()
      };
      
      await savePlansAPI(plans);
      console.warn('使用本地存储作为备用更新计划');
      return true;
    } catch (localError) {
      console.error('本地存储备用也失败:', localError);
    }
    throw error;
  }
}

/**
 * 删除计划
 * @param {string} planId 计划ID
 * @returns {Promise<boolean>} 是否删除成功
 */
export async function deletePlanAPI(planId) {
  try {
    // 使用正式的 API 调用，匹配后端 Controller
    // API 接口设计：DELETE ${API_BASE_URL}/plans/${planId}
    // 返回格式：{ code: 200, message: string }
    // 错误格式：{ code: number, message: string }
    
    const response = await fetch(`${API_BASE_URL}/plans/${planId}`, {
      method: 'DELETE',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
    });
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(result.message || '删除计划失败');
    }
    
    return true;
    
  } catch (error) {
    console.warn('API调用失败，使用本地存储:', error);
    // 如果 API 调用失败，尝试使用本地存储作为备用
    try {
      const plans = await getPlansAPI();
      const filteredPlans = plans.filter(p => p.id !== planId);
      
      if (plans.length === filteredPlans.length) {
        throw new Error('计划不存在');
      }
      
      await savePlansAPI(filteredPlans);
      console.warn('使用本地存储作为备用删除计划');
      return true;
    } catch (localError) {
      console.error('本地存储备用也失败:', localError);
    }
    throw error;
  }
}

/**
 * 创建容器
 * @param {Object} containerData 容器数据
 * @returns {Promise<Object>} 创建的容器对象
 */
export async function createContainerAPI(containerData) {
  try {
    const response = await fetch(`${API_BASE_URL}/containers`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
      body: JSON.stringify(containerData),
    });

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }

    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(result.message || '创建容器失败');
    }

    return result.data;
  } catch (error) {
    console.error('创建容器API调用失败:', error);
    throw error;
  }
}

/**
 * 绑定容器到计划
 * @param {string} planId 计划ID
 * @param {string} containerId 容器ID
 * @returns {Promise<boolean>} 是否绑定成功
 */
export async function bindContainerToPlanAPI(planId, containerId) {
  try {
    const response = await fetch(`${API_BASE_URL}/plans/${planId}/containers`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
      body: JSON.stringify({ containerId }),
    });

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }

    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(result.message || '绑定容器失败');
    }

    return true;
  } catch (error) {
    console.error('绑定容器到计划API调用失败:', error);
    throw error;
  }
}

/**
 * 解绑计划中的容器
 * @param {string} planId 计划ID
 * @param {string} containerId 容器ID
 * @returns {Promise<boolean>} 是否解绑成功
 */
export async function unbindContainerFromPlanAPI(planId, containerId) {
  try {
    // 使用正式的 API 调用，匹配后端 Controller
    // API 接口设计：DELETE ${API_BASE_URL}/plans/${planId}/containers/${containerId}
    // 返回格式：{ code: 200, message: string }
    // 错误格式：{ code: number, message: string }
    
    const response = await fetch(`${API_BASE_URL}/plans/${planId}/containers/${containerId}`, {
      method: 'DELETE',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
    });
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(result.message || '解绑容器失败');
    }
    
    return true;
    
  } catch (error) {
    console.warn('API调用失败，使用本地存储:', error);
    // 如果 API 调用失败，尝试使用本地存储作为备用
    try {
      const plans = await getPlansAPI();
      const plan = plans.find(p => p.id === planId);
      
      if (!plan) {
        throw new Error('计划不存在');
      }
      
      const containerIndex = plan.containerIds.indexOf(containerId);
      if (containerIndex > -1) {
        plan.containerIds.splice(containerIndex, 1);
        plan.updatedAt = new Date().toISOString();
        await savePlansAPI(plans);
      }
      
      console.warn('使用本地存储作为备用解绑容器');
      return true;
    } catch (localError) {
      console.error('本地存储备用也失败:', localError);
    }
    throw error;
  }
}

/**
 * 获取计划绑定的容器列表API
 * @param {string} planId 计划ID
 * @returns {Promise<Array>} 绑定的容器列表
 */
export async function getPlanContainersAPI(planId) {
  try {
    // API 接口设计：GET ${API_BASE_URL}/plans/${planId}/containers
    // 返回格式：{ code: 200, message: string, data: Array }
    // 错误格式：{ code: number, message: string }
    
    const response = await fetch(`${API_BASE_URL}/plans/${planId}/containers`, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        // 'Authorization': 'Bearer ' + getAuthToken(), // 如需认证
      },
    });
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const result = await response.json();
    if (result.code !== 200) {
      throw new Error(result.message || '获取计划容器列表失败');
    }
    
    return result.data || [];
    
  } catch (error) {
    console.warn('API调用失败，使用本地存储备用:', error);
    // 如果 API 调用失败，尝试使用本地存储作为备用
    try {
      const plans = await getPlansAPI();
      const plan = plans.find(p => p.id === planId);
      if (!plan) {
        throw new Error('计划不存在');
      }
      
      // 从本地容器数据中过滤出绑定的容器
      const containers = await getFromAPI(STORAGE_KEYS.CONTAINERS) || [];
      const boundContainers = containers.filter(container => 
        plan.containerIds && plan.containerIds.includes(container.id)
      );
      
      console.warn('使用本地存储作为备用获取计划容器列表');
      return boundContainers;
    } catch (localError) {
      console.error('本地存储备用也失败:', localError);
    }
    throw error;
  }
}